#include "domino.h"

//Construtor
Domino::Domino(GLfloat base, GLfloat height, int texture, int texturemax, GLfloat x_spc, GLfloat y_spc, GLfloat z_spc, GLfloat x_rot, GLfloat y_rot, GLfloat z_rot)
{
    //Controle de queda do domino
    falling = false;
    fall_speed = 0.8;
    
    this->texture = texture;
    this->texturemax = texturemax;

    this->base = base;
    this->height = height;

    this->x_spc = x_spc;
    this->y_spc = y_spc;
    this->z_spc = z_spc;
    this->x_rot = x_rot;
    this->y_rot = y_rot;
    this->z_rot = z_rot/DEGTORAD;
    
    //Controle do angulo do domino
    z_rot_max = this->z_rot + 40.0;
    z_rot_min = this->z_rot - 40.0;
    
}

//Destrutor
Domino::~Domino(){}

//Pegar o angulo do domino em queda em radianos
GLfloat Domino::GET_x_angle(int rad)
{
    if(rad)
        return x_rot*DEGTORAD;
    else
        return x_rot;
}

//Pegar o angulo que o domino esta virado
GLfloat Domino::GET_z_angle(int rad)
{
    if(rad)
        return z_rot*DEGTORAD;
    else
        return z_rot;
}

//Pegar a texture
int Domino::GET_texture()
{
    return texture;   
}

//Virar domino
void Domino::ADD_z_angle(GLfloat angle)
{
    if(!falling) 
    {
        //Dar uma folga para o angulo
        GLfloat folga = 1.0;
        //Girar o domino caso ele esteja dentro dos limites
        if(z_rot < z_rot_max+folga && z_rot > z_rot_min-folga) z_rot += angle;
        //Caso ele ultrapase os limites, coloca-lo em uma posicao dentro dos limites
        if(z_rot > z_rot_max) z_rot = z_rot_max-folga;
        if(z_rot < z_rot_min) z_rot = z_rot_min+folga;
    }
}

void Domino::SET_texture()
{
    if(texture+1 < texturemax) ++texture; else texture = 0;
}

//Fazer o domino cair
void Domino::DominoFall()
{
    falling = true;
}
 
//Fazer o domino cair
void Domino::DominoReset()
{
    falling = false;
    fall_speed = 0.8;
}

//Acelerar a queda
void Domino::ADD_fall_speed(GLfloat add)
{
    if(falling) fall_speed += add;
}
 
//Desenhar o domino
void Domino::DrawDomino(GLUquadricObj *quadratic, GLuint tex[4][3])
{
    //Fazer cair
    if(falling && x_rot < 80) x_rot += fall_speed;
    //Levantar o domino
    if(!falling && x_rot) x_rot = 0.0f;
    
    //Desenhar o domino
    glPushMatrix();
        //Aplicar textura
        glBindTexture(GL_TEXTURE_2D, tex[texture][0]);
        //Posicionar o domino
        glTranslatef(x_spc, y_spc, z_spc);
        //Rotacionar o domino
        glRotatef(y_rot, 0.0f, 1.0f, 0.0f);
        glRotatef(z_rot, 0.0f, 0.0f, 1.0f);
        glRotatef(x_rot, 1.0f, 0.0f, 0.0f);
        glTranslatef(0.0f, 0.0f, -height/2);
        //Escalonar o cubo para que fique do tamanho correto
        glScalef(base, base/2, 1.0f);
        //Fazer um cubo escalonado
        glutSolidCube(height);
    glPopMatrix();
    
    glFlush();
    
    
}
